{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 233,
   "id": "2010e239",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.nn.functional as F\n",
    "import copy\n",
    "\n",
    "import sys \n",
    "sys.path.append(\"..\") \n",
    "import rl_utils as rl_utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "id": "81add012",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PolicyNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return F.softmax(self.fc2(x), dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "id": "e0e6db3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ValueNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, 1)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return self.fc2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "id": "29603a3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_advantage(gamma, lmbda, td_delta):\n",
    "    td_delta = td_delta.detach().numpy()\n",
    "    advantage_list = []\n",
    "    advantage = 0.0\n",
    "    for delta in td_delta[::-1]:\n",
    "        advantage = gamma * lmbda * advantage + delta\n",
    "        advantage_list.append(advantage)\n",
    "    advantage_list.reverse()\n",
    "    return torch.tensor(advantage_list, dtype=torch.float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9165027b",
   "metadata": {},
   "source": [
    "### 算法核心步骤\n",
    "1. 初始化：\n",
    " - 解向量 x 初始化为零向量\n",
    " - 残差 r 初始化为梯度 g\n",
    " - 搜索方向 p 初始化为梯度 g\n",
    "2. 迭代过程：\n",
    " - 计算海森矩阵 - 向量乘积：通过 hessian_matrix_vector_product 函数计算 Hp，避免显式构建海森矩阵\n",
    " - 计算步长：\\(\\alpha = \\frac{r^T r}{p^T Hp}\\)\n",
    "    $$\n",
    "     \\alpha = \\frac{\\mathbf{r}^T \\mathbf{r}}{\\mathbf{p}^T H\\mathbf{p}}\n",
    "     $$\n",
    " - 更新解向量：\\(x \\leftarrow x + \\alpha p\\)\n",
    " $$\n",
    "     \\mathbf{x} \\leftarrow \\mathbf{x} + \\alpha \\mathbf{p}\n",
    "     $$\n",
    " - 更新残差：\\(r \\leftarrow r - \\alpha Hp\\)\n",
    "   $$\n",
    "     \\mathbf{r} \\leftarrow \\mathbf{r} - \\alpha H\\mathbf{p}\n",
    "     $$\n",
    " - 计算共轭系数：\\(\\beta = \\frac{r_{\\text{new}}^T r_{\\text{new}}}{r^T r}\\)\n",
    "  $$\n",
    "     \\beta = \\frac{\\mathbf{r}_{\\text{new}}^T \\mathbf{r}_{\\text{new}}}{\\mathbf{r}^T \\mathbf{r}}\n",
    "     $$\n",
    " - 更新搜索方向：\\(p \\leftarrow r_{\\text{new}} + \\beta p\\)\n",
    " $$\n",
    "     \\mathbf{p} \\leftarrow \\mathbf{r}_{\\text{new}} + \\beta \\mathbf{p}\n",
    "     $$\n",
    "3. 终止条件：\n",
    " - 达到最大迭代次数（10 次）残差的范数平方小于阈值 \\(10^{-10}\\)\n",
    "### 关键函数依赖\n",
    "- self.hessian_matrix_vector_product(states, old_action_dists, p)：计算海森矩阵 H 与向量 p 的乘积 Hp，通常使用 Fisher 信息矩阵的无偏估计替代真实海森矩阵，这在强化学习中很常见。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "edfabc46",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TRPO:\n",
    "    '''TRPO算法'''\n",
    "    def __init__(self, hidden_dim, state_space, action_space, lmbda, kl_constraint, alpha, critic_lr, gamma, device):\n",
    "        state_dim = state_space.shape[0]\n",
    "        action_dim = action_space.n\n",
    "        # 策略网络参数不需要优化器更新\n",
    "        self.actor = PolicyNet(state_dim, hidden_dim, action_dim).to(device)\n",
    "        self.critic = ValueNet(state_dim, hidden_dim).to(device)\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=critic_lr)\n",
    "        self.gamma = gamma\n",
    "        # GAE参数\n",
    "        self.lmbda = lmbda\n",
    "        # KL距离最大限制\n",
    "        self.kl_constraint = kl_constraint\n",
    "        # 线性搜索参数\n",
    "        self.alpha = alpha\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        probs = self.actor(state)\n",
    "        action_dist = torch.distributions.Categorical(probs)\n",
    "        action = action_dist.sample()\n",
    "        return action.item()\n",
    "\n",
    "    def hessian_matrix_vector_product(self, states, old_action_dists, vector):\n",
    "        '''计算黑塞矩阵和一个向量的乘积'''\n",
    "        '''\n",
    "        计算 KL 散度关于策略网络参数的黑塞矩阵，再将其与输入向量相乘。黑塞矩阵是二阶导数矩阵，在优化中用于近似目标函数的局部曲率。\n",
    "        输入：\n",
    "            states：环境状态批次。\n",
    "            old_action_dists：旧策略的动作分布（通常是类别分布）。\n",
    "            vector：要与黑塞矩阵相乘的向量。\n",
    "        输出：黑塞矩阵与向量的乘积结果。\n",
    "        '''\n",
    "        new_action_dists = torch.distributions.Categorical(self.actor(states))\n",
    "        '''\n",
    "        通过当前策略网络（self.actor）对输入状态计算动作概率分布。\n",
    "        '''\n",
    "        # 计算平均KL距离\n",
    "        kl = torch.mean(torch.distributions.kl.kl_divergence(old_action_dists, new_action_dists))\n",
    "        '''\n",
    "        kl_divergence计算两个类别分布之间的 KL 散度，再取平均值。KL 散度衡量两个分布的差异，是 TRPO 中约束策略更新步长的核心指标。\n",
    "        '''\n",
    "        kl_grad = torch.autograd.grad(kl, self.actor.parameters(), create_graph=True)\n",
    "        '''\n",
    "        create_graph=True允许后续计算二阶导数（保留计算图）。\n",
    "        '''\n",
    "        kl_grad_vector = torch.cat([grad.view(-1) for grad in kl_grad])\n",
    "        '''\n",
    "        将各参数的梯度展平并拼接成一维向量（kl_grad_vector）。\n",
    "        '''\n",
    "        # KL距离的梯度先和向量进行点积运算\n",
    "        kl_grad_vector_product = torch.dot(kl_grad_vector, vector)\n",
    "        '''\n",
    "        这一步将一阶导数信息与输入向量做点积，为二阶导数计算做准备。\n",
    "        '''\n",
    "        grad2 = torch.autograd.grad(kl_grad_vector_product, self.actor.parameters())\n",
    "        grad2_vector = torch.cat([grad.view(-1) for grad in grad2])\n",
    "        '''\n",
    "        再次求导得到二阶导数信息，结果即为黑塞矩阵与向量的乘积。\n",
    "        '''\n",
    "        return grad2_vector\n",
    "    \n",
    "    def conjugate_gradient(self, grad, states, old_action_dists):\n",
    "        # 共轭梯度法求解方程\n",
    "        x = torch.zeros_like(grad)\n",
    "        r = grad.clone()\n",
    "        p = grad.clone()\n",
    "        rdotr = torch.dot(r, r)\n",
    "        for i in range(10):\n",
    "            # 共轭梯度主循环\n",
    "            Hp = self.hessian_matrix_vector_product(states, old_action_dists, p)\n",
    "             # 计算步长 alpha，公式为 r^T*r / p^T*Hp\n",
    "            alpha = rdotr / torch.dot(p, Hp)\n",
    "            # 更新解向量 x\n",
    "            x += alpha * p\n",
    "            # 更新残差 r\n",
    "            r -= alpha * Hp\n",
    "            # 计算新残差的点积\n",
    "            new_rdotr = torch.dot(r, r)\n",
    "            # 残差足够小时提前终止迭代（收敛判定）\n",
    "            if new_rdotr < 1e-10:\n",
    "                break\n",
    "            # 计算共轭系数 beta，公式为 new_r^T*new_r / r^T*r\n",
    "            beta = new_rdotr / rdotr\n",
    "            # 更新搜索方向 p 为新残差与 beta*旧搜索方向的线性组合\n",
    "            p = r + beta * p\n",
    "            # 更新 rdotr 为新残差的点积\n",
    "            rdotr = new_rdotr\n",
    "        return x\n",
    "    \n",
    "    def compute_surrogate_obj(self, states, actions, advantage, old_log_probs, actor):\n",
    "        # 计算策略目标\n",
    "        log_probs = torch.log(actor(states).gather(1, actions))\n",
    "        ratio = torch.exp(log_probs - old_log_probs)\n",
    "        return torch.mean(ratio * advantage)\n",
    "    \n",
    "    def line_search(self, states, actions, advantage, old_log_probs, old_action_dists, max_vec):\n",
    "        # 线性搜索\n",
    "        old_para = torch.nn.utils.convert_parameters.parameters_to_vector(self.actor.parameters())\n",
    "        old_obj = self.compute_surrogate_obj(states, actions, advantage, old_log_probs, self.actor)\n",
    "        for i in range(15):\n",
    "            # 线性搜索主循环\n",
    "            coef = self.alpha**i\n",
    "            new_para = old_para + coef * max_vec\n",
    "            new_actor = copy.deepcopy(self.actor)\n",
    "            torch.nn.utils.convert_parameters.vector_to_parameters(new_para, new_actor.parameters())\n",
    "            new_action_dists = torch.distributions.Categorical(new_actor(states))\n",
    "            kl_div = torch.mean(torch.distributions.kl.kl_divergence(old_action_dists, new_action_dists))\n",
    "            new_obj = self.compute_surrogate_obj(states, actions, advantage, old_log_probs, new_actor)\n",
    "            if new_obj > old_obj and kl_div < self.kl_constraint:\n",
    "                return new_para\n",
    "        return old_para\n",
    "\n",
    "    \n",
    "    def policy_learn(self, states, actions, old_action_dists, old_log_probs, advantage):\n",
    "        # 更新策略函数\n",
    "        surrogate_obj = self.compute_surrogate_obj(states, actions, advantage, old_log_probs, self.actor)\n",
    "        grads = torch.autograd.grad(surrogate_obj, self.actor.parameters())\n",
    "        obj_grad = torch.cat([grad.view(-1) for grad in grads]).detach()\n",
    "        # 用共轭梯度法计算x = H^(-1)g\n",
    "        descent_direction = self.conjugate_gradient(obj_grad, states, old_action_dists)\n",
    "        Hd = self.hessian_matrix_vector_product(states, old_action_dists, descent_direction)\n",
    "        max_coef = torch.sqrt(2 * self.kl_constraint / (torch.dot(descent_direction, Hd) + 1e-8))\n",
    "        # 线性搜索\n",
    "        new_para = self.line_search(states, actions, advantage, old_log_probs, old_action_dists, descent_direction * max_coef)\n",
    "        # 用线性搜索后的参数更新策略\n",
    "        torch.nn.utils.convert_parameters.vector_to_parameters(new_para, self.actor.parameters())\n",
    "\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        states = torch.tensor(transition_dict['states'], dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "\n",
    "        td_target = rewards + self.gamma * self.critic(next_states) * (1 - dones)\n",
    "        td_delta = td_target - self.critic(states)\n",
    "        advantage = compute_advantage(self.gamma, self.lmbda, td_delta).to(self.device)\n",
    "        old_log_probs = torch.log(self.actor(states).gather(1, actions)).detach()\n",
    "        old_action_dists = torch.distributions.Categorical(self.actor(states).detach())\n",
    "        critic_loss = torch.mean(F.mse_loss(self.critic(states), td_target.detach()))\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        # 更新价值函数\n",
    "        self.critic_optimizer.step()\n",
    "        # 更新策略函数\n",
    "        self.policy_learn(states, actions, old_action_dists, old_log_probs, advantage)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "63d05cf8",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'gym' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 11\u001b[39m\n\u001b[32m      8\u001b[39m device = \u001b[33m'\u001b[39m\u001b[33mcpu\u001b[39m\u001b[33m'\u001b[39m\n\u001b[32m     10\u001b[39m env_name = \u001b[33m'\u001b[39m\u001b[33mCartPole-v1\u001b[39m\u001b[33m'\u001b[39m\n\u001b[32m---> \u001b[39m\u001b[32m11\u001b[39m env = \u001b[43mgym\u001b[49m.make(env_name)\n\u001b[32m     12\u001b[39m torch.manual_seed(\u001b[32m0\u001b[39m)\n\u001b[32m     13\u001b[39m agent = TRPO(hidden_dim, env.observation_space, env.action_space, lmbda, kl_constraint, alpha, critic_lr, gamma, device)\n",
      "\u001b[31mNameError\u001b[39m: name 'gym' is not defined"
     ]
    }
   ],
   "source": [
    "num_episodes = 1000\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "lmbda = 0.95\n",
    "critic_lr = 1e-2\n",
    "kl_constraint = 0.0005\n",
    "alpha = 0.5\n",
    "device = 'cpu'\n",
    "\n",
    "env_name = 'CartPole-v1'\n",
    "env = gym.make(env_name)\n",
    "torch.manual_seed(0)\n",
    "agent = TRPO(hidden_dim, env.observation_space, env.action_space, lmbda, kl_constraint, alpha, critic_lr, gamma, device)\n",
    "return_list = rl_utils.train_on_policy_agent(env, agent, num_episodes)\n",
    "episodes_list = list(range(len(return_list)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8a5656e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title(f'TRPO on {env_name}')\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title(f'TRPO on {env_name}')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
